home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 February: Tool Chest / Dev.CD Feb 94.toast / Tool Chest / Development Platforms / MPW Related / MPW Interfaces / PInterfaces / Quickdraw.p < prev    next >
Encoding:
Text File  |  1993-09-17  |  26.7 KB  |  964 lines  |  [TEXT/MPS ]
  1. {
  2.     File:        Quickdraw.p
  3.  
  4.     Copyright:    © 1983-1993 by Apple Computer, Inc.
  5.                 All rights reserved.
  6.  
  7.     Version:    System 7.1 for ETO #11
  8.     Created:    Tuesday, March 30, 1993 18:00
  9.  
  10. }
  11.  
  12. {$IFC UNDEFINED UsingIncludes}
  13. {$SETC UsingIncludes := 0}
  14. {$ENDC}
  15.  
  16. {$IFC NOT UsingIncludes}
  17.  UNIT Quickdraw;
  18.  INTERFACE
  19. {$ENDC}
  20.  
  21. {$IFC UNDEFINED UsingQuickdraw}
  22. {$SETC UsingQuickdraw := 1}
  23.  
  24. {$I+}
  25. {$SETC QuickdrawIncludes := UsingIncludes}
  26. {$SETC UsingIncludes := 1}
  27. {$IFC UNDEFINED UsingTypes}
  28. {$I $$Shell(PInterfaces)Types.p}
  29. {$ENDC}
  30. {$IFC UNDEFINED UsingQuickdrawText}
  31. {$I $$Shell(PInterfaces)QuickdrawText.p}
  32. {$ENDC}
  33. {$SETC UsingIncludes := QuickdrawIncludes}
  34.  
  35. CONST
  36. invalColReq = -1;                            {invalid color table request}
  37.  
  38. { transfer modes }
  39. srcCopy = 0;                                {the 16 transfer modes}
  40. srcOr = 1;
  41. srcXor = 2;
  42. srcBic = 3;
  43. notSrcCopy = 4;
  44. notSrcOr = 5;
  45. notSrcXor = 6;
  46. notSrcBic = 7;
  47. patCopy = 8;
  48. patOr = 9;
  49. patXor = 10;
  50. patBic = 11;
  51. notPatCopy = 12;
  52. notPatOr = 13;
  53. notPatXor = 14;
  54. notPatBic = 15;
  55.  
  56. { Special Text Transfer Mode }
  57. grayishTextOr = 49;
  58.  
  59. { Arithmetic transfer modes }
  60. blend = 32;
  61. addPin = 33;
  62. addOver = 34;
  63. subPin = 35;
  64. addMax = 37;
  65. adMax = 37;
  66. subOver = 38;
  67. adMin = 39;
  68. ditherCopy = 64;
  69.  
  70. { Transparent mode constant }
  71. transparent = 36;
  72.  
  73. { QuickDraw color separation constants }
  74. normalBit = 0;                                {normal screen mapping}
  75. inverseBit = 1;                                {inverse screen mapping}
  76. redBit = 4;                                    {RGB additive mapping}
  77. greenBit = 3;
  78. blueBit = 2;
  79. cyanBit = 8;                                {CMYBk subtractive mapping}
  80. magentaBit = 7;
  81. yellowBit = 6;
  82. blackBit = 5;
  83. blackColor = 33;                            {colors expressed in these mappings}
  84. whiteColor = 30;
  85. redColor = 205;
  86. greenColor = 341;
  87. blueColor = 409;
  88. cyanColor = 273;
  89. magentaColor = 137;
  90. yellowColor = 69;
  91.  
  92. picLParen = 0;                                {standard picture comments}
  93. picRParen = 1;
  94.  
  95.  
  96. clutType = 0;                                {0 if lookup table}
  97. fixedType = 1;                                {1 if fixed table}
  98. directType = 2;                                {2 if direct values}
  99.  
  100. gdDevType = 0;                                {0 = monochrome 1 = color}
  101. hasAuxMenuBar = 6;                            {1 if device has an aux menu bar on it}
  102. burstDevice = 7;
  103. ext32Device = 8;
  104. ramInit = 10;                                {1 if initialized from 'scrn' resource}
  105. mainScreen = 11;                            {1 if main screen }
  106. allInit = 12;                                {1 if all devices initialized }
  107. screenDevice = 13;                            {1 if screen device [not used]}
  108. noDriver = 14;                                {1 if no driver for this GDevice }
  109. screenActive = 15;                            {1 if in use}
  110.  
  111. hiliteBit = 7;                                {flag bit in HiliteMode (lowMem flag)}
  112. pHiliteBit = 0;                                {flag bit in HiliteMode used with BitClr procedure}
  113.  
  114. defQDColors = 127;                            {resource ID of clut for default QDColors}
  115.  
  116. { pixel type }
  117. RGBDirect = 16;                                {16 & 32 bits/pixel pixelType value }
  118.  
  119. { pmVersion values }
  120. baseAddr32 = 4;                                {pixmap base address is 32-bit address}
  121.  
  122. rgnOverflowErr = -147;                        {Region accumulation failed. Resulting region may be currupt }
  123. insufficientStackErr = -149;                {QuickDraw could not complete the operation }
  124.  
  125.  
  126.  
  127. TYPE
  128. GrafVerb = (frame,paint,erase,invert,fill);
  129.  
  130. PixelType = (chunky,chunkyPlanar,planar);
  131.  
  132.  
  133.  
  134. PatPtr = ^Pattern;
  135. PatHandle = ^PatPtr;
  136.  
  137. Pattern = PACKED ARRAY [0..7] OF 0..255;
  138.  
  139. QDByte = SignedByte;
  140.  
  141. QDPtr = Ptr;                                { blind pointer }
  142.  
  143. QDHandle = Handle;                            { blind handle }
  144.  
  145.  
  146.  
  147. QDErr = INTEGER;
  148.  
  149. Bits16 = ARRAY [0..15] OF INTEGER;
  150.  
  151.  
  152.  
  153. DeviceLoopFlags = SET OF (singleDevices,dontMatchSeeds,allDevices,DeviceLoopFlags3,
  154.  DeviceLoopFlags4,DeviceLoopFlags5,DeviceLoopFlags6,DeviceLoopFlags7,DeviceLoopFlags8,
  155.  DeviceLoopFlags9,DeviceLoopFlags10,DeviceLoopFlags11,DeviceLoopFlags12,
  156.  DeviceLoopFlags13,DeviceLoopFlags14,DeviceLoopFlags15,DeviceLoopFlags16,
  157.  DeviceLoopFlags17,DeviceLoopFlags18,DeviceLoopFlags19,DeviceLoopFlags20,
  158.  DeviceLoopFlags21,DeviceLoopFlags22,DeviceLoopFlags23,DeviceLoopFlags24,
  159.  DeviceLoopFlags25,DeviceLoopFlags26,DeviceLoopFlags27,DeviceLoopFlags28,
  160.  DeviceLoopFlags29,DeviceLoopFlags30,DeviceLoopFlags31);
  161.  
  162.  
  163. BitMapPtr = ^BitMap;
  164. BitMapHandle = ^BitMapPtr;
  165. BitMap = RECORD
  166.  baseAddr: Ptr;
  167.  rowBytes: INTEGER;
  168.  bounds: Rect;
  169.  END;
  170.  
  171. CursPtr = ^Cursor;
  172. CursHandle = ^CursPtr;
  173. Cursor = RECORD
  174.  data: Bits16;
  175.  mask: Bits16;
  176.  hotSpot: Point;
  177.  END;
  178.  
  179. PenState = RECORD
  180.  pnLoc: Point;
  181.  pnSize: Point;
  182.  pnMode: INTEGER;
  183.  pnPat: Pattern;
  184.  END;
  185.  
  186. RgnPtr = ^Region;
  187. RgnHandle = ^RgnPtr;
  188. Region = RECORD
  189.  rgnSize: INTEGER;                            {size in bytes}
  190.  rgnBBox: Rect;                                {enclosing rectangle}
  191.  END;
  192.  
  193. PicPtr = ^Picture;
  194. PicHandle = ^PicPtr;
  195. Picture = RECORD
  196.  picSize: INTEGER;
  197.  picFrame: Rect;
  198.  END;
  199.  
  200. PolyPtr = ^Polygon;
  201. PolyHandle = ^PolyPtr;
  202. Polygon = RECORD
  203.  polySize: INTEGER;
  204.  polyBBox: Rect;
  205.  polyPoints: ARRAY [0..0] OF Point;
  206.  END;
  207.  
  208. QDProcsPtr = ^QDProcs;
  209. QDProcs = RECORD
  210.  textProc: Ptr;
  211.  lineProc: Ptr;
  212.  rectProc: Ptr;
  213.  rRectProc: Ptr;
  214.  ovalProc: Ptr;
  215.  arcProc: Ptr;
  216.  polyProc: Ptr;
  217.  rgnProc: Ptr;
  218.  bitsProc: Ptr;
  219.  commentProc: Ptr;
  220.  txMeasProc: Ptr;
  221.  getPicProc: Ptr;
  222.  putPicProc: Ptr;
  223.  END;
  224.  
  225. GrafPtr = ^GrafPort;
  226. GrafPort = RECORD
  227.  device: INTEGER;
  228.  portBits: BitMap;
  229.  portRect: Rect;
  230.  visRgn: RgnHandle;
  231.  clipRgn: RgnHandle;
  232.  bkPat: Pattern;
  233.  fillPat: Pattern;
  234.  pnLoc: Point;
  235.  pnSize: Point;
  236.  pnMode: INTEGER;
  237.  pnPat: Pattern;
  238.  pnVis: INTEGER;
  239.  txFont: INTEGER;
  240.  txFace: Style;                                {txFace is unpacked byte but push as short}
  241.  txMode: INTEGER;
  242.  txSize: INTEGER;
  243.  spExtra: Fixed;
  244.  fgColor: LONGINT;
  245.  bkColor: LONGINT;
  246.  colrBit: INTEGER;
  247.  patStretch: INTEGER;
  248.  picSave: Handle;
  249.  rgnSave: Handle;
  250.  polySave: Handle;
  251.  grafProcs: QDProcsPtr;
  252.  END;
  253.  
  254.  
  255. WindowPtr = GrafPtr;
  256.  
  257. {typedef pascal Boolean (*ColorSearchProcPtr)(RGBColor *rgb, long *position);
  258. typedef pascal Boolean (*ColorComplementProcPtr)(RGBColor *rgb);}
  259.  
  260. RGBColor = RECORD
  261.  red: INTEGER;                                {magnitude of red component}
  262.  green: INTEGER;                            {magnitude of green component}
  263.  blue: INTEGER;                                {magnitude of blue component}
  264.  END;
  265.  
  266. ColorSpecPtr = ^ColorSpec;
  267. ColorSpec = RECORD
  268.  value: INTEGER;                            {index or other value}
  269.  rgb: RGBColor;                                {true color}
  270.  END;
  271.  
  272.  
  273. CSpecArray = ARRAY [0..0] OF ColorSpec;
  274.  
  275. CTabPtr = ^ColorTable;
  276. CTabHandle = ^CTabPtr;
  277. ColorTable = RECORD
  278.  ctSeed: LONGINT;                            {unique identifier for table}
  279.  ctFlags: INTEGER;                            {high bit: 0 = PixMap; 1 = device}
  280.  ctSize: INTEGER;                            {number of entries in CTTable}
  281.  ctTable: CSpecArray;                        {array [0..0] of ColorSpec}
  282.  END;
  283.  
  284. MatchRec = RECORD
  285.  red: INTEGER;
  286.  green: INTEGER;
  287.  blue: INTEGER;
  288.  matchData: LONGINT;
  289.  END;
  290.  
  291. PixMapPtr = ^PixMap;
  292. PixMapHandle = ^PixMapPtr;
  293. PixMap = RECORD
  294.  baseAddr: Ptr;                                {pointer to pixels}
  295.  rowBytes: INTEGER;                            {offset to next line}
  296.  bounds: Rect;                                {encloses bitmap}
  297.  pmVersion: INTEGER;                        {pixMap version number}
  298.  packType: INTEGER;                            {defines packing format}
  299.  packSize: LONGINT;                            {length of pixel data}
  300.  hRes: Fixed;                                {horiz. resolution (ppi)}
  301.  vRes: Fixed;                                {vert. resolution (ppi)}
  302.  pixelType: INTEGER;                        {defines pixel type}
  303.  pixelSize: INTEGER;                        {# bits in pixel}
  304.  cmpCount: INTEGER;                            {# components in pixel}
  305.  cmpSize: INTEGER;                            {# bits per component}
  306.  planeBytes: LONGINT;                        {offset to next plane}
  307.  pmTable: CTabHandle;                        {color map for this pixMap}
  308.  pmReserved: LONGINT;                        {for future use. MUST BE 0}
  309.  END;
  310.  
  311. PixPatPtr = ^PixPat;
  312. PixPatHandle = ^PixPatPtr;
  313. PixPat = RECORD
  314.  patType: INTEGER;                            {type of pattern}
  315.  patMap: PixMapHandle;                        {the pattern's pixMap}
  316.  patData: Handle;                            {pixmap's data}
  317.  patXData: Handle;                            {expanded Pattern data}
  318.  patXValid: INTEGER;                        {flags whether expanded Pattern valid}
  319.  patXMap: Handle;                            {Handle to expanded Pattern data}
  320.  pat1Data: Pattern;                            {old-Style pattern/RGB color}
  321.  END;
  322.  
  323. CCrsrPtr = ^CCrsr;
  324. CCrsrHandle = ^CCrsrPtr;
  325. CCrsr = RECORD
  326.  crsrType: INTEGER;                            {type of cursor}
  327.  crsrMap: PixMapHandle;                        {the cursor's pixmap}
  328.  crsrData: Handle;                            {cursor's data}
  329.  crsrXData: Handle;                            {expanded cursor data}
  330.  crsrXValid: INTEGER;                        {depth of expanded data (0 if none)}
  331.  crsrXHandle: Handle;                        {future use}
  332.  crsr1Data: Bits16;                            {one-bit cursor}
  333.  crsrMask: Bits16;                            {cursor's mask}
  334.  crsrHotSpot: Point;                        {cursor's hotspot}
  335.  crsrXTable: LONGINT;                        {private}
  336.  crsrID: LONGINT;                            {private}
  337.  END;
  338.  
  339. CIconPtr = ^CIcon;
  340. CIconHandle = ^CIconPtr;
  341. CIcon = RECORD
  342.  iconPMap: PixMap;                            {the icon's pixMap}
  343.  iconMask: BitMap;                            {the icon's mask}
  344.  iconBMap: BitMap;                            {the icon's bitMap}
  345.  iconData: Handle;                            {the icon's data}
  346.  iconMaskData: ARRAY [0..0] OF INTEGER;        {icon's mask and BitMap data}
  347.  END;
  348.  
  349. GammaTblPtr = ^GammaTbl;
  350. GammaTblHandle = ^GammaTblPtr;
  351. GammaTbl = RECORD
  352.  gVersion: INTEGER;                            {gamma version number}
  353.  gType: INTEGER;                            {gamma data type}
  354.  gFormulaSize: INTEGER;                        {Formula data size}
  355.  gChanCnt: INTEGER;                            {number of channels of data}
  356.  gDataCnt: INTEGER;                            {number of values/channel}
  357.  gDataWidth: INTEGER;                        {bits/corrected value (data packed to next larger byte size)}
  358.  gFormulaData: ARRAY [0..0] OF INTEGER;        {data for formulas followed by gamma values}
  359.  END;
  360.  
  361. ITabPtr = ^ITab;
  362. ITabHandle = ^ITabPtr;
  363. ITab = RECORD
  364.  iTabSeed: LONGINT;                            {copy of CTSeed from source CTable}
  365.  iTabRes: INTEGER;                            {bits/channel resolution of iTable}
  366.  iTTable: ARRAY [0..0] OF SignedByte;        {byte colortable index values}
  367.  END;
  368.  
  369. SProcPtr = ^SProcRec;
  370. SProcHndl = ^SProcPtr;
  371. SProcRec = RECORD
  372.  nxtSrch: Handle;                            {SProcHndl Handle to next SProcRec}
  373.  srchProc: ProcPtr;                            {pointer to search procedure}
  374.  END;
  375.  
  376. CProcPtr = ^CProcRec;
  377. CProcHndl = ^CProcPtr;
  378. CProcRec = RECORD
  379.  nxtComp: CProcHndl;                        {CProcHndl Handle to next CProcRec}
  380.  compProc: ProcPtr;                            {pointer to complement procedure}
  381.  END;
  382.  
  383. GDPtr = ^GDevice;
  384. GDHandle = ^GDPtr;
  385. GDevice = RECORD
  386.  gdRefNum: INTEGER;                            {driver's unit number}
  387.  gdID: INTEGER;                                {client ID for search procs}
  388.  gdType: INTEGER;                            {fixed/CLUT/direct}
  389.  gdITable: ITabHandle;                        {Handle to inverse lookup table}
  390.  gdResPref: INTEGER;                        {preferred resolution of GDITable}
  391.  gdSearchProc: SProcHndl;                    {search proc list head}
  392.  gdCompProc: CProcHndl;                        {complement proc list}
  393.  gdFlags: INTEGER;                            {grafDevice flags word}
  394.  gdPMap: PixMapHandle;                        {describing pixMap}
  395.  gdRefCon: LONGINT;                            {reference value}
  396.  gdNextGD: GDHandle;                        {GDHandle Handle of next gDevice}
  397.  gdRect: Rect;                                { device's bounds in global coordinates}
  398.  gdMode: LONGINT;                            {device's current mode}
  399.  gdCCBytes: INTEGER;                        {depth of expanded cursor data}
  400.  gdCCDepth: INTEGER;                        {depth of expanded cursor data}
  401.  gdCCXData: Handle;                            {Handle to cursor's expanded data}
  402.  gdCCXMask: Handle;                            {Handle to cursor's expanded mask}
  403.  gdReserved: LONGINT;                        {future use. MUST BE 0}
  404.  END;
  405.  
  406. GVarPtr = ^GrafVars;
  407. GVarHandle = ^GVarPtr;
  408. GrafVars = RECORD
  409.  rgbOpColor: RGBColor;                        {color for addPin  subPin and average}
  410.  rgbHiliteColor: RGBColor;                    {color for hiliting}
  411.  pmFgColor: Handle;                            {palette Handle for foreground color}
  412.  pmFgIndex: INTEGER;                        {index value for foreground}
  413.  pmBkColor: Handle;                            {palette Handle for background color}
  414.  pmBkIndex: INTEGER;                        {index value for background}
  415.  pmFlags: INTEGER;                            {flags for Palette Manager}
  416.  END;
  417.  
  418. CQDProcsPtr = ^CQDProcs;
  419. CQDProcs = RECORD
  420.  textProc: Ptr;
  421.  lineProc: Ptr;
  422.  rectProc: Ptr;
  423.  rRectProc: Ptr;
  424.  ovalProc: Ptr;
  425.  arcProc: Ptr;
  426.  polyProc: Ptr;
  427.  rgnProc: Ptr;
  428.  bitsProc: Ptr;
  429.  commentProc: Ptr;
  430.  txMeasProc: Ptr;
  431.  getPicProc: Ptr;
  432.  putPicProc: Ptr;
  433.  opcodeProc: Ptr;                            {fields added to QDProcs}
  434.  newProc1: Ptr;
  435.  newProc2: Ptr;
  436.  newProc3: Ptr;
  437.  newProc4: Ptr;
  438.  newProc5: Ptr;
  439.  newProc6: Ptr;
  440.  END;
  441.  
  442. CGrafPtr = ^CGrafPort;
  443. CGrafPort = RECORD
  444.  device: INTEGER;
  445.  portPixMap: PixMapHandle;                    {port's pixel map}
  446.  portVersion: INTEGER;                        {high 2 bits always set}
  447.  grafVars: Handle;                            {Handle to more fields}
  448.  chExtra: INTEGER;                            {character extra}
  449.  pnLocHFrac: INTEGER;                        {pen fraction}
  450.  portRect: Rect;
  451.  visRgn: RgnHandle;
  452.  clipRgn: RgnHandle;
  453.  bkPixPat: PixPatHandle;                    {background pattern}
  454.  rgbFgColor: RGBColor;                        {RGB components of fg}
  455.  rgbBkColor: RGBColor;                        {RGB components of bk}
  456.  pnLoc: Point;
  457.  pnSize: Point;
  458.  pnMode: INTEGER;
  459.  pnPixPat: PixPatHandle;                    {pen's pattern}
  460.  fillPixPat: PixPatHandle;                    {fill pattern}
  461.  pnVis: INTEGER;
  462.  txFont: INTEGER;
  463.  txFace: Style;                                {txFace is unpacked byte  push as short}
  464.  txMode: INTEGER;
  465.  txSize: INTEGER;
  466.  spExtra: Fixed;
  467.  fgColor: LONGINT;
  468.  bkColor: LONGINT;
  469.  colrBit: INTEGER;
  470.  patStretch: INTEGER;
  471.  picSave: Handle;
  472.  rgnSave: Handle;
  473.  polySave: Handle;
  474.  grafProcs: CQDProcsPtr;
  475.  END;
  476.  
  477.  
  478. CWindowPtr = CGrafPtr;
  479.  
  480. ReqListRec = RECORD
  481.  reqLSize: INTEGER;                            {request list size}
  482.  reqLData: ARRAY [0..0] OF INTEGER;            {request list data}
  483.  END;
  484.  
  485. OpenCPicParams = RECORD
  486.  srcRect: Rect;
  487.  hRes: Fixed;
  488.  vRes: Fixed;
  489.  version: INTEGER;
  490.  reserved1: INTEGER;
  491.  reserved2: LONGINT;
  492.  END;
  493.  
  494.  
  495. DeviceLoopDrawingProcPtr = ProcPtr;
  496.  
  497.  
  498. VAR
  499. {$PUSH}
  500. {$J+}
  501.  thePort: GrafPtr;
  502.  white: Pattern;
  503.  black: Pattern;
  504.  gray: Pattern;
  505.  ltGray: Pattern;
  506.  dkGray: Pattern;
  507.  arrow: Cursor;
  508.  screenBits: BitMap;
  509.  randSeed: LONGINT;
  510. {$POP}
  511.  
  512.  
  513.  
  514. PROCEDURE InitGraf(globalPtr: Ptr);
  515.  INLINE $A86E;
  516. PROCEDURE OpenPort(port: GrafPtr);
  517.  INLINE $A86F;
  518. PROCEDURE InitPort(port: GrafPtr);
  519.  INLINE $A86D;
  520. PROCEDURE ClosePort(port: GrafPtr);
  521.  INLINE $A87D;
  522. PROCEDURE SetPort(port: GrafPtr);
  523.  INLINE $A873;
  524. PROCEDURE GetPort(VAR port: GrafPtr);
  525.  INLINE $A874;
  526. PROCEDURE GrafDevice(device: INTEGER);
  527.  INLINE $A872;
  528. PROCEDURE SetPortBits(bm: BitMap);
  529.  INLINE $A875;
  530. PROCEDURE PortSize(width: INTEGER;height: INTEGER);
  531.  INLINE $A876;
  532. PROCEDURE MovePortTo(leftGlobal: INTEGER;topGlobal: INTEGER);
  533.  INLINE $A877;
  534. PROCEDURE SetOrigin(h: INTEGER;v: INTEGER);
  535.  INLINE $A878;
  536. PROCEDURE SetClip(rgn: RgnHandle);
  537.  INLINE $A879;
  538. PROCEDURE GetClip(rgn: RgnHandle);
  539.  INLINE $A87A;
  540. PROCEDURE ClipRect(r: Rect);
  541.  INLINE $A87B;
  542. PROCEDURE BackPat(pat: Pattern);
  543.  INLINE $A87C;
  544. PROCEDURE InitCursor;
  545.  INLINE $A850;
  546. PROCEDURE SetCursor(crsr: Cursor);
  547.  INLINE $A851;
  548. PROCEDURE HideCursor;
  549.  INLINE $A852;
  550. PROCEDURE ShowCursor;
  551.  INLINE $A853;
  552. PROCEDURE ObscureCursor;
  553.  INLINE $A856;
  554. PROCEDURE HidePen;
  555.  INLINE $A896;
  556. PROCEDURE ShowPen;
  557.  INLINE $A897;
  558. PROCEDURE GetPen(VAR pt: Point);
  559.  INLINE $A89A;
  560. PROCEDURE GetPenState(VAR pnState: PenState);
  561.  INLINE $A898;
  562. PROCEDURE SetPenState(pnState: PenState);
  563.  INLINE $A899;
  564. PROCEDURE PenSize(width: INTEGER;height: INTEGER);
  565.  INLINE $A89B;
  566. PROCEDURE PenMode(mode: INTEGER);
  567.  INLINE $A89C;
  568. PROCEDURE PenPat(pat: Pattern);
  569.  INLINE $A89D;
  570. PROCEDURE PenNormal;
  571.  INLINE $A89E;
  572. PROCEDURE MoveTo(h: INTEGER;v: INTEGER);
  573.  INLINE $A893;
  574. PROCEDURE Move(dh: INTEGER;dv: INTEGER);
  575.  INLINE $A894;
  576. PROCEDURE LineTo(h: INTEGER;v: INTEGER);
  577.  INLINE $A891;
  578. PROCEDURE Line(dh: INTEGER;dv: INTEGER);
  579.  INLINE $A892;
  580. PROCEDURE ForeColor(color: LONGINT);
  581.  INLINE $A862;
  582. PROCEDURE BackColor(color: LONGINT);
  583.  INLINE $A863;
  584. PROCEDURE ColorBit(whichBit: INTEGER);
  585.  INLINE $A864;
  586. PROCEDURE SetRect(VAR r: Rect;left: INTEGER;top: INTEGER;right: INTEGER;
  587.  bottom: INTEGER);
  588.  INLINE $A8A7;
  589. PROCEDURE OffsetRect(VAR r: Rect;dh: INTEGER;dv: INTEGER);
  590.  INLINE $A8A8;
  591. PROCEDURE InsetRect(VAR r: Rect;dh: INTEGER;dv: INTEGER);
  592.  INLINE $A8A9;
  593. FUNCTION SectRect(src1: Rect;src2: Rect;VAR dstRect: Rect): BOOLEAN;
  594.  INLINE $A8AA;
  595. PROCEDURE UnionRect(src1: Rect;src2: Rect;VAR dstRect: Rect);
  596.  INLINE $A8AB;
  597. FUNCTION EqualRect(rect1: Rect;rect2: Rect): BOOLEAN;
  598.  INLINE $A8A6;
  599. FUNCTION EmptyRect(r: Rect): BOOLEAN;
  600.  INLINE $A8AE;
  601. PROCEDURE FrameRect(r: Rect);
  602.  INLINE $A8A1;
  603. PROCEDURE PaintRect(r: Rect);
  604.  INLINE $A8A2;
  605. PROCEDURE EraseRect(r: Rect);
  606.  INLINE $A8A3;
  607. PROCEDURE InvertRect(r: Rect);
  608.  INLINE $A8A4;
  609. PROCEDURE FillRect(r: Rect;pat: Pattern);
  610.  INLINE $A8A5;
  611. PROCEDURE FrameOval(r: Rect);
  612.  INLINE $A8B7;
  613. PROCEDURE PaintOval(r: Rect);
  614.  INLINE $A8B8;
  615. PROCEDURE EraseOval(r: Rect);
  616.  INLINE $A8B9;
  617. PROCEDURE InvertOval(r: Rect);
  618.  INLINE $A8BA;
  619. PROCEDURE FillOval(r: Rect;pat: Pattern);
  620.  INLINE $A8BB;
  621. PROCEDURE FrameRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  622.  INLINE $A8B0;
  623. PROCEDURE PaintRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  624.  INLINE $A8B1;
  625. PROCEDURE EraseRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  626.  INLINE $A8B2;
  627. PROCEDURE InvertRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  628.  INLINE $A8B3;
  629. PROCEDURE FillRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER;
  630.  pat: Pattern);
  631.  INLINE $A8B4;
  632. PROCEDURE FrameArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  633.  INLINE $A8BE;
  634. PROCEDURE PaintArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  635.  INLINE $A8BF;
  636. PROCEDURE EraseArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  637.  INLINE $A8C0;
  638. PROCEDURE InvertArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  639.  INLINE $A8C1;
  640. PROCEDURE FillArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER;pat: Pattern);
  641.  INLINE $A8C2;
  642. FUNCTION NewRgn: RgnHandle;
  643.  INLINE $A8D8;
  644. PROCEDURE OpenRgn;
  645.  INLINE $A8DA;
  646. PROCEDURE CloseRgn(dstRgn: RgnHandle);
  647.  INLINE $A8DB;
  648. FUNCTION BitMapToRegionGlue(region: RgnHandle;bMap: BitMap): OSErr;
  649. FUNCTION BitMapToRegion(region: RgnHandle;bMap: BitMap): OSErr;
  650.  INLINE $A8D7;
  651. PROCEDURE DisposeRgn(rgn: RgnHandle);
  652.  INLINE $A8D9;
  653. PROCEDURE CopyRgn(srcRgn: RgnHandle;dstRgn: RgnHandle);
  654.  INLINE $A8DC;
  655. PROCEDURE SetEmptyRgn(rgn: RgnHandle);
  656.  INLINE $A8DD;
  657. PROCEDURE SetRectRgn(rgn: RgnHandle;left: INTEGER;top: INTEGER;right: INTEGER;
  658.  bottom: INTEGER);
  659.  INLINE $A8DE;
  660. PROCEDURE RectRgn(rgn: RgnHandle;r: Rect);
  661.  INLINE $A8DF;
  662. PROCEDURE OffsetRgn(rgn: RgnHandle;dh: INTEGER;dv: INTEGER);
  663.  INLINE $A8E0;
  664. PROCEDURE InsetRgn(rgn: RgnHandle;dh: INTEGER;dv: INTEGER);
  665.  INLINE $A8E1;
  666. PROCEDURE SectRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  667.  INLINE $A8E4;
  668. PROCEDURE UnionRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  669.  INLINE $A8E5;
  670. PROCEDURE DiffRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  671.  INLINE $A8E6;
  672. PROCEDURE XorRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  673.  INLINE $A8E7;
  674. FUNCTION RectInRgn(r: Rect;rgn: RgnHandle): BOOLEAN;
  675.  INLINE $A8E9;
  676. FUNCTION EqualRgn(rgnA: RgnHandle;rgnB: RgnHandle): BOOLEAN;
  677.  INLINE $A8E3;
  678. FUNCTION EmptyRgn(rgn: RgnHandle): BOOLEAN;
  679.  INLINE $A8E2;
  680. PROCEDURE FrameRgn(rgn: RgnHandle);
  681.  INLINE $A8D2;
  682. PROCEDURE PaintRgn(rgn: RgnHandle);
  683.  INLINE $A8D3;
  684. PROCEDURE EraseRgn(rgn: RgnHandle);
  685.  INLINE $A8D4;
  686. PROCEDURE InvertRgn(rgn: RgnHandle);
  687.  INLINE $A8D5;
  688. PROCEDURE FillRgn(rgn: RgnHandle;pat: Pattern);
  689.  INLINE $A8D6;
  690. PROCEDURE ScrollRect(r: Rect;dh: INTEGER;dv: INTEGER;updateRgn: RgnHandle);
  691.  INLINE $A8EF;
  692. PROCEDURE CopyBits(srcBits: BitMap;dstBits: BitMap;srcRect: Rect;dstRect: Rect;
  693.  mode: INTEGER;maskRgn: RgnHandle);
  694.  INLINE $A8EC;
  695. PROCEDURE SeedFill(srcPtr: Ptr;dstPtr: Ptr;srcRow: INTEGER;dstRow: INTEGER;
  696.  height: INTEGER;words: INTEGER;seedH: INTEGER;seedV: INTEGER);
  697.  INLINE $A839;
  698. PROCEDURE CalcMask(srcPtr: Ptr;dstPtr: Ptr;srcRow: INTEGER;dstRow: INTEGER;
  699.  height: INTEGER;words: INTEGER);
  700.  INLINE $A838;
  701. PROCEDURE CopyMask(srcBits: BitMap;maskBits: BitMap;dstBits: BitMap;srcRect: Rect;
  702.  maskRect: Rect;dstRect: Rect);
  703.  INLINE $A817;
  704. FUNCTION OpenPicture(picFrame: Rect): PicHandle;
  705.  INLINE $A8F3;
  706. PROCEDURE PicComment(kind: INTEGER;dataSize: INTEGER;dataHandle: Handle);
  707.  INLINE $A8F2;
  708. PROCEDURE ClosePicture;
  709.  INLINE $A8F4;
  710. PROCEDURE DrawPicture(myPicture: PicHandle;dstRect: Rect);
  711.  INLINE $A8F6;
  712. PROCEDURE KillPicture(myPicture: PicHandle);
  713.  INLINE $A8F5;
  714. FUNCTION OpenPoly: PolyHandle;
  715.  INLINE $A8CB;
  716. PROCEDURE ClosePoly;
  717.  INLINE $A8CC;
  718. PROCEDURE KillPoly(poly: PolyHandle);
  719.  INLINE $A8CD;
  720. PROCEDURE OffsetPoly(poly: PolyHandle;dh: INTEGER;dv: INTEGER);
  721.  INLINE $A8CE;
  722. PROCEDURE FramePoly(poly: PolyHandle);
  723.  INLINE $A8C6;
  724. PROCEDURE PaintPoly(poly: PolyHandle);
  725.  INLINE $A8C7;
  726. PROCEDURE ErasePoly(poly: PolyHandle);
  727.  INLINE $A8C8;
  728. PROCEDURE InvertPoly(poly: PolyHandle);
  729.  INLINE $A8C9;
  730. PROCEDURE FillPoly(poly: PolyHandle;pat: Pattern);
  731.  INLINE $A8CA;
  732. PROCEDURE SetPt(VAR pt: Point;h: INTEGER;v: INTEGER);
  733.  INLINE $A880;
  734. PROCEDURE LocalToGlobal(VAR pt: Point);
  735.  INLINE $A870;
  736. PROCEDURE GlobalToLocal(VAR pt: Point);
  737.  INLINE $A871;
  738. FUNCTION Random: INTEGER;
  739.  INLINE $A861;
  740. PROCEDURE StuffHex(thingPtr: Ptr;s: Str255);
  741.  INLINE $A866;
  742. FUNCTION GetPixel(h: INTEGER;v: INTEGER): BOOLEAN;
  743.  INLINE $A865;
  744. PROCEDURE ScalePt(VAR pt: Point;srcRect: Rect;dstRect: Rect);
  745.  INLINE $A8F8;
  746. PROCEDURE MapPt(VAR pt: Point;srcRect: Rect;dstRect: Rect);
  747.  INLINE $A8F9;
  748. PROCEDURE MapRect(VAR r: Rect;srcRect: Rect;dstRect: Rect);
  749.  INLINE $A8FA;
  750. PROCEDURE MapRgn(rgn: RgnHandle;srcRect: Rect;dstRect: Rect);
  751.  INLINE $A8FB;
  752. PROCEDURE MapPoly(poly: PolyHandle;srcRect: Rect;dstRect: Rect);
  753.  INLINE $A8FC;
  754. PROCEDURE SetStdProcs(VAR procs: QDProcs);
  755.  INLINE $A8EA;
  756. PROCEDURE StdRect(verb: GrafVerb;r: Rect);
  757.  INLINE $A8A0;
  758. PROCEDURE StdRRect(verb: GrafVerb;r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  759.  INLINE $A8AF;
  760. PROCEDURE StdOval(verb: GrafVerb;r: Rect);
  761.  INLINE $A8B6;
  762. PROCEDURE StdArc(verb: GrafVerb;r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  763.  INLINE $A8BD;
  764. PROCEDURE StdPoly(verb: GrafVerb;poly: PolyHandle);
  765.  INLINE $A8C5;
  766. PROCEDURE StdRgn(verb: GrafVerb;rgn: RgnHandle);
  767.  INLINE $A8D1;
  768. PROCEDURE StdBits(VAR srcBits: BitMap;VAR srcRect: Rect;dstRect: Rect;mode: INTEGER;
  769.     maskRgn: RgnHandle);
  770.     INLINE $A8EB;
  771. PROCEDURE StdComment(kind: INTEGER;dataSize: INTEGER;dataHandle: Handle);
  772.  INLINE $A8F1;
  773. PROCEDURE StdGetPic(dataPtr: Ptr;byteCount: INTEGER);
  774.  INLINE $A8EE;
  775. PROCEDURE StdPutPic(dataPtr: Ptr;byteCount: INTEGER);
  776.  INLINE $A8F0;
  777. PROCEDURE AddPt(src: Point;VAR dst: Point);
  778.  INLINE $A87E;
  779. FUNCTION EqualPt(pt1: Point;pt2: Point): BOOLEAN;
  780.  INLINE $A881;
  781. FUNCTION PtInRect(pt: Point;r: Rect): BOOLEAN;
  782.  INLINE $A8AD;
  783. PROCEDURE Pt2Rect(pt1: Point;pt2: Point;VAR dstRect: Rect);
  784.  INLINE $A8AC;
  785. PROCEDURE PtToAngle(r: Rect;pt: Point;VAR angle: INTEGER);
  786.  INLINE $A8C3;
  787. FUNCTION PtInRgn(pt: Point;rgn: RgnHandle): BOOLEAN;
  788.  INLINE $A8E8;
  789. PROCEDURE StdLine(newPt: Point);
  790.  INLINE $A890;
  791. PROCEDURE OpenCPort(port: CGrafPtr);
  792.  INLINE $AA00;
  793. PROCEDURE InitCPort(port: CGrafPtr);
  794.  INLINE $AA01;
  795. PROCEDURE CloseCPort(port: CGrafPtr);
  796.  INLINE $A87D;
  797. FUNCTION NewPixMap: PixMapHandle;
  798.  INLINE $AA03;
  799. PROCEDURE DisposPixMap(pm: PixMapHandle);
  800.  INLINE $AA04;
  801. PROCEDURE DisposePixMap(pm: PixMapHandle);
  802.  INLINE $AA04;
  803. PROCEDURE CopyPixMap(srcPM: PixMapHandle;dstPM: PixMapHandle);
  804.  INLINE $AA05;
  805. FUNCTION NewPixPat: PixPatHandle;
  806.  INLINE $AA07;
  807. PROCEDURE DisposPixPat(pp: PixPatHandle);
  808.  INLINE $AA08;
  809. PROCEDURE DisposePixPat(pp: PixPatHandle);
  810.  INLINE $AA08;
  811. PROCEDURE CopyPixPat(srcPP: PixPatHandle;dstPP: PixPatHandle);
  812.  INLINE $AA09;
  813. PROCEDURE PenPixPat(pp: PixPatHandle);
  814.  INLINE $AA0A;
  815. PROCEDURE BackPixPat(pp: PixPatHandle);
  816.  INLINE $AA0B;
  817. FUNCTION GetPixPat(patID: INTEGER): PixPatHandle;
  818.  INLINE $AA0C;
  819. PROCEDURE MakeRGBPat(pp: PixPatHandle;myColor: RGBColor);
  820.  INLINE $AA0D;
  821. PROCEDURE FillCRect(r: Rect;pp: PixPatHandle);
  822.  INLINE $AA0E;
  823. PROCEDURE FillCOval(r: Rect;pp: PixPatHandle);
  824.  INLINE $AA0F;
  825. PROCEDURE FillCRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER;
  826.  pp: PixPatHandle);
  827.  INLINE $AA10;
  828. PROCEDURE FillCArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER;pp: PixPatHandle);
  829.  INLINE $AA11;
  830. PROCEDURE FillCRgn(rgn: RgnHandle;pp: PixPatHandle);
  831.  INLINE $AA12;
  832. PROCEDURE FillCPoly(poly: PolyHandle;pp: PixPatHandle);
  833.  INLINE $AA13;
  834. PROCEDURE RGBForeColor(color: RGBColor);
  835.  INLINE $AA14;
  836. PROCEDURE RGBBackColor(color: RGBColor);
  837.  INLINE $AA15;
  838. PROCEDURE SetCPixel(h: INTEGER;v: INTEGER;cPix: RGBColor);
  839.  INLINE $AA16;
  840. PROCEDURE SetPortPix(pm: PixMapHandle);
  841.  INLINE $AA06;
  842. PROCEDURE GetCPixel(h: INTEGER;v: INTEGER;VAR cPix: RGBColor);
  843.  INLINE $AA17;
  844. PROCEDURE GetForeColor(VAR color: RGBColor);
  845.  INLINE $AA19;
  846. PROCEDURE GetBackColor(VAR color: RGBColor);
  847.  INLINE $AA1A;
  848. PROCEDURE SeedCFill(srcBits: BitMap;dstBits: BitMap;srcRect: Rect;dstRect: Rect;
  849.  seedH: INTEGER;seedV: INTEGER;matchProc: ProcPtr;matchData: LONGINT);
  850.  INLINE $AA50;
  851. PROCEDURE CalcCMask(srcBits: BitMap;dstBits: BitMap;srcRect: Rect;dstRect: Rect;
  852.  seedRGB: RGBColor;matchProc: ProcPtr;matchData: LONGINT);
  853.  INLINE $AA4F;
  854. FUNCTION OpenCPicture(newHeader: OpenCPicParams): PicHandle;
  855.  INLINE $AA20;
  856. PROCEDURE OpColor(color: RGBColor);
  857.  INLINE $AA21;
  858. PROCEDURE HiliteColor(color: RGBColor);
  859.  INLINE $AA22;
  860. PROCEDURE DisposCTable(cTable: CTabHandle);
  861.  INLINE $AA24;
  862. PROCEDURE DisposeCTable(cTable: CTabHandle);
  863.  INLINE $AA24;
  864. FUNCTION GetCTable(ctID: INTEGER): CTabHandle;
  865.  INLINE $AA18;
  866. FUNCTION GetCCursor(crsrID: INTEGER): CCrsrHandle;
  867.  INLINE $AA1B;
  868. PROCEDURE SetCCursor(cCrsr: CCrsrHandle);
  869.  INLINE $AA1C;
  870. PROCEDURE AllocCursor;
  871.  INLINE $AA1D;
  872. PROCEDURE DisposCCursor(cCrsr: CCrsrHandle);
  873.  INLINE $AA26;
  874. PROCEDURE DisposeCCursor(cCrsr: CCrsrHandle);
  875.  INLINE $AA26;
  876. FUNCTION GetCIcon(iconID: INTEGER): CIconHandle;
  877.  INLINE $AA1E;
  878. PROCEDURE PlotCIcon(theRect: Rect;theIcon: CIconHandle);
  879.  INLINE $AA1F;
  880. PROCEDURE DisposCIcon(theIcon: CIconHandle);
  881.  INLINE $AA25;
  882. PROCEDURE DisposeCIcon(theIcon: CIconHandle);
  883.  INLINE $AA25;
  884. PROCEDURE SetStdCProcs(VAR procs: CQDProcs);
  885.  INLINE $AA4E;
  886. FUNCTION GetMaxDevice(globalRect: Rect): GDHandle;
  887.  INLINE $AA27;
  888. FUNCTION GetCTSeed: LONGINT;
  889.  INLINE $AA28;
  890. FUNCTION GetDeviceList: GDHandle;
  891.  INLINE $AA29;
  892. FUNCTION GetMainDevice: GDHandle;
  893.  INLINE $AA2A;
  894. FUNCTION GetNextDevice(curDevice: GDHandle): GDHandle;
  895.  INLINE $AA2B;
  896. FUNCTION TestDeviceAttribute(gdh: GDHandle;attribute: INTEGER): BOOLEAN;
  897.  INLINE $AA2C;
  898. PROCEDURE SetDeviceAttribute(gdh: GDHandle;attribute: INTEGER;value: BOOLEAN);
  899.  INLINE $AA2D;
  900. PROCEDURE InitGDevice(qdRefNum: INTEGER;mode: LONGINT;gdh: GDHandle);
  901.  INLINE $AA2E;
  902. FUNCTION NewGDevice(refNum: INTEGER;mode: LONGINT): GDHandle;
  903.  INLINE $AA2F;
  904. PROCEDURE DisposGDevice(gdh: GDHandle);
  905.  INLINE $AA30;
  906. PROCEDURE DisposeGDevice(gdh: GDHandle);
  907.  INLINE $AA30;
  908. PROCEDURE SetGDevice(gd: GDHandle);
  909.  INLINE $AA31;
  910. FUNCTION GetGDevice: GDHandle;
  911.  INLINE $AA32;
  912. FUNCTION Color2Index(myColor: RGBColor): LONGINT;
  913.  INLINE $AA33;
  914. PROCEDURE Index2Color(index: LONGINT;VAR aColor: RGBColor);
  915.  INLINE $AA34;
  916. PROCEDURE InvertColor(VAR myColor: RGBColor);
  917.  INLINE $AA35;
  918. FUNCTION RealColor(color: RGBColor): BOOLEAN;
  919.  INLINE $AA36;
  920. PROCEDURE GetSubTable(myColors: CTabHandle;iTabRes: INTEGER;targetTbl: CTabHandle);
  921.  INLINE $AA37;
  922. PROCEDURE MakeITable(cTabH: CTabHandle;iTabH: ITabHandle;res: INTEGER);
  923.  INLINE $AA39;
  924. PROCEDURE AddSearch(searchProc: ProcPtr);
  925.  INLINE $AA3A;
  926. PROCEDURE AddComp(compProc: ProcPtr);
  927.  INLINE $AA3B;
  928. PROCEDURE DelSearch(searchProc: ProcPtr);
  929.  INLINE $AA4C;
  930. PROCEDURE DelComp(compProc: ProcPtr);
  931.  INLINE $AA4D;
  932. PROCEDURE SubPt(src: Point;VAR dst: Point);
  933.  INLINE $A87F;
  934. PROCEDURE SetClientID(id: INTEGER);
  935.  INLINE $AA3C;
  936. PROCEDURE ProtectEntry(index: INTEGER;protect: BOOLEAN);
  937.  INLINE $AA3D;
  938. PROCEDURE ReserveEntry(index: INTEGER;reserve: BOOLEAN);
  939.  INLINE $AA3E;
  940. PROCEDURE SetEntries(start: INTEGER;count: INTEGER;aTable: CSpecArray);
  941.  INLINE $AA3F;
  942. PROCEDURE SaveEntries(srcTable: CTabHandle;resultTable: CTabHandle;VAR selection: ReqListRec);
  943.  INLINE $AA49;
  944. PROCEDURE RestoreEntries(srcTable: CTabHandle;dstTable: CTabHandle;VAR selection: ReqListRec);
  945.  INLINE $AA4A;
  946. FUNCTION QDError: INTEGER;
  947.  INLINE $AA40;
  948. PROCEDURE CopyDeepMask(srcBits: BitMap;maskBits: BitMap;dstBits: BitMap;
  949.  srcRect: Rect;maskRect: Rect;dstRect: Rect;mode: INTEGER;maskRgn: RgnHandle);
  950.  INLINE $AA51;
  951. PROCEDURE DeviceLoop(drawingRgn: RgnHandle;drawingProc: DeviceLoopDrawingProcPtr;
  952.  userData: LONGINT;flags: DeviceLoopFlags);
  953.  INLINE $ABCA;
  954. FUNCTION GetMaskTable: Ptr;
  955.  INLINE $A836,$2E88;
  956.  
  957.  
  958. {$ENDC} { UsingQuickdraw }
  959.  
  960. {$IFC NOT UsingIncludes}
  961.  END.
  962. {$ENDC}
  963.  
  964.